#abs()   用于返回一个数的绝对值，如果传入的参数是一个复数，则返回该复数的模
#返回整数的X的绝对值
# x = -88
# print(abs(x)) #输出的结果是 88
# #返回浮点数的 y 的绝对值
# y = -3.14
# print(abs(y))   #输出结果为 3.14
# #返回复数Z的模
# z = 4 + 3j
# print(abs(z))  #输出结果为 5.0

#aiter()  是一个协程函数，用于获取可迭代对象的异步迭代器  注意：只能用于异步编程中，在同步编程中会报异常
# import asyncio
# async def async_generator():
#     for i in range(3):
#         await asyncio.sleep(1)
#         yield i
# async def main():
#     #获取可迭代对象异步迭代器
#     async  for i in asyncio.aiter(async_generator()):
#         print(i)
# asyncio.run(main())

# all() 用于判断给定的可迭代对象中的所有元素是否均为真值(True)，如果可迭代对象对象中所有元素都是真值返回True,否则False
#注意：0,空字符串、空列表、空字典，None等作为假值处理
#判断列表 a 中所有元素是否为真值
# a = [1,2,3,4,'hello',None]
# print(all(a)) #输出结果为 False
#
# #判断元组 b 中所有元素是否为真值
# b = (0,'',[],False)
# print(all(b))  #输出结果为False
#
# #判断集合 c 中所有元素是否为真值
# c = {1,2,True,'hello'}
# print(all(c))

# any() 用于判断给定的可迭代对象中是否有任意一个元素是为真值，有一个元素返回True,则返回False
#判断列表 d 中所有元素是否为真值
# d = [0,'',False,[],None]
# print(any(d))  #输出结果为 False
#
# #判断元组 e 中所有元素是否为真值
# e = (0,'',[],False)
# print(any(e))  #输出结果为False
#
# #判断集合 f 中所有元素是否为真值
# f = {1,2,True,'hello'}
# print(any(f))  #输出结果为 True

# ascii() 将一个对象转换为ASCII字符的字符串，字节串和其他对象转换为包含ASCII字符的字符串,
# 如果输入的对象本身就是包含ASCII字符的字符串，则输出与原输入相同的字符串  注意：对于某些特殊字符进行转义，例如单引号，双引号，反斜杠等
# s = input()  # 输入："hello ,你好"
# print(ascii(s))  #输出  'hello,\u4f60\u597d'

# bin()  将一个整数转换为二进制表示形式的字符串
# 输出结果是一个以'0b'开头的字符串，后面跟着整数的二进制表示形式，如果输入的不是整数，则会引发‘TypeError'异常

# j = int(input())  #输入整数
# print(bin(j))     #输出二进制
#可以用字符串切片去掉字符串开头的’ob'
# bin_num = bin(j)[2:]
# print(bin_num)
# 转换其他类型的数据
# print(bin(0x10))  #输出 0b10000 ，将十六进制转换为二进制字符串
# print(bin(0b1001)) #输出 0b1001 ，将二进制转换为二进制字符串
# print(bin(0o12))   #输出 0b1010,将八进制转换为二进制字符串
# print(format(14, '#b'), format(14, 'b'))  #去掉前缀 输出 0b1110 1110


# bool() 将一个值转换为布尔类型，当参数为假是返回False,则返回True
# g = 0
# h = ''
# k = []
# l = {}
# print(bool(g))   #False
# print(bool(h))   #False
# print(bool(k))   #False
# print(bool(l))   #False

# z  =  1
# x  =  'hello'
# n  =  [1,  2,  3]
# m  =  {'a':  1,  'b':  2}
#
# print(bool(z))    #  True
# print(bool(x))    #  True
# print(bool(n))    #  True
# print(bool(m))    #  True


# breakpoint()  作用是设置一个断点（就是程序在特定位置停下来，等待用户进一步操作，
# 在此处可以查看程序的上下文学习，进行一些调试操作  开头引入
# def foo(x,y):
#     z = x + y
#     breakpoint()  # 设置断点
#     if z < 0:
#         z = 0
#     return z
# result = foo(-1,2)
# print(result)
#程序会暂停并进入交互模式，可以使用pdb提供的命令进行调试，
# 例如查看当前变量的值、单步执行、查看堆栈信息等。
# 从交互模式退出时，程序会继续执行。

# bytearray（source, encoding='utf-8', errors='strict'） 用于创建一个新的bytearray对象，接受三个参数 source ， encoding  和  errors
#source  参数表示用于初始化 bytearray 对象的值。它可以是包含整数的序列、包含字节（bytes）的序列或字符串。如果不指定  source  参数，则新建的 bytearray 对象长度为0。
#encoding  参数表示将字符串编码成 bytes 类型时使用的编码字符集，默认为 UTF-8 编码。
#errors  参数表示指定编解码错误时的处理方式，默认为  'strict' ，表示遇到错误时抛出异常。
#创建空的 bytearray 对象
# b = bytearray()
# print()
# #从包含整数的序列创建 bytearray 对象
# b = bytearray([65,66,67])
# print(b)  #bytearray(b'ABC')
# # 从字符串创建 bytearray 对象，
# b = bytearray('你好','utf-8')
# print(b)  #bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')

# bytes([source[, encoding[, errors]]])  将一个字符串、字节串或整数等转换为一个bytes 对象，
# source  参数可以是字符串、字节串、整数或包含整数的可迭代对象。如果不指定  source  参数，则默认创建一个长度为0的 bytes 对象。
# encoding  参数表示将字符串编码成 bytes 类型时使用的编码字符集，默认为 UTF-8 编码。
# errors  参数表示指定编解码错误时的处理方式，默认为  'strict' ，表示遇到错误时抛出异常。

# 字符串和字节串的相互转换
# b = bytes('hello','utf-8')
# s = b.decode('utf-8')
# print(b)  #b'hello'
# print(s)  #hello
# # 整数转换为 bytes 对象
# b = bytes([65,66,67])
# print(b)  #b'ABC'
# # 通过迭代器创建 bytes 对象
# b = bytes(range(5))
# print(b)  #b'\x00\x01\x02\x03\x04'

# callable() 用于检查一个对象是否可调用，即是否是可调用的，如果是可调用的，返回True 否则返回False
# 可以用它来判断函数、方法、类、lambda 函数等是否可以调用
# def func():
#     pass
#
# class MyClass():
#     def __init__(self):
#         self.x = 1
#
#     def method(self):
#         pass
#
# obj_1 = func
# obj_2 = MyClass()
#
# print(callable(obj_1))  # True
# print(callable(obj_2))  # False
# 第一个打印语句打印 True，因为 object_2.method 是一个可调用的函数。
# 第二个 print 语句打印 True，因为 lambda 函数是可调用的。
# 第三个和第四个打印语句打印 False，因为整数和字符串都不可调用。
# print(callable(obj_2.method))  # True
# print(callable(lambda x: x + 1))  # True
# print(callable(123))  # False
# print(callable('hello'))  # False

# chr(i) 用于将整数转换为对应的ASCII字符，返回值是一个字符串
# print(chr(97)) #a
# print(chr(8364))  #€
# print(chr(128512))  #😀

# classmethod（function） 用于定义类方法，类方法与普通实例方法的区别在于，类方法只能访问变量和类方法，而不能访问实例变量和实例方法
# class MyClass():
#     x = 0
#     def __init__(self, y):
#         self.y = y
#     def normal_method(self):
#         print("这是一个普通的实例方法")
#     @classmethod
#     def class_method(cls):
#         print("这是一个类方法")
#         print("cls.x =", cls.x)
#     @staticmethod
#     def static_method():
#         print("这是一个静态方法")
# obj = MyClass(1)
# obj.normal_method()
# MyClass.class_method()
# MyClass.static_method()
# @classmethod  装饰器将  class_method()  方法转换为类方法。
# class_method()  方法中的  cls  参数表示该类本身，可以访问类变量  x 。
# 需要注意的是，类方法可以通过类名和实例对象访问。
# 在上面的示例中， class_method()  方法既可以通过  MyClass.class_method()  调用，
# 也可以通过  obj.class_method()  调用，这两种调用方式返回的结果是相同的。

# compile（source, filename, mode） 用于将字符串编译为可执行代码或AST对象
#source  参数表示要编译的字符串、代码对象或 AST 对象；
# filename  参数表示文件名（如果代码是从文件中读取的，则需要指定该参数）；
# mode  参数表示编译模式：
# code_str = 'print("hello,word!")'
# code_obj = compile(code_str,'','exec')
# exec(code_obj)
# expr_str = '2 + 3'
# expr_obj = compile(expr_str,'','eval')
# result = eval(expr_obj)
# print(result)
#code_str  字符串包含一个  print  语句， expr_str  字符串包含一个加法表达式。
# 使用  compile()  函数将这两个字符串编译为代码对象和表达式对象，
# 并使用  exec()  函数和  eval()  函数分别执行它们

# complex（real[, imag]） 用于创建一个复数，复数是由实部和虚部组成的数值，
#real  表示复数的实部，必须是一个数字或字符串，如果省略，则默认为 0；
# imag  表示复数的虚部，必须是一个数字或字符串，如果省略，则默认为 0。
# 如果  real  和  imag  都是数字，则表示  real + imag * j  的复数；
# 如果其中一个是字符串，则表示将该字符串解析为复数

a = complex(2,3)
b = complex(1,-3)
c = complex('2+3j')
print(a)  #(2+3j)
print(b)   #(1-3j)
print(c)  # (2+3j)



